home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 August: Tool Chest / Dev.CD Aug 94.toast / Tool Chest / Games / Game Sample Code / SpriteWorld 1.0b3 / Examples / SpaceRocks / SpaceGame.c < prev    next >
Encoding:
Text File  |  1993-06-13  |  12.7 KB  |  681 lines  |  [TEXT/KAHL]
  1. ///--------------------------------------------------------------------------------------
  2. // SpaceGame.c
  3. //
  4. // Created:    6/18/92 at 8:03:00 PM
  5. // By:        Tony Myles
  6. //
  7. //    Copyright: © 1992-93 Tony Myles, All rights reserved worldwide.
  8. ///--------------------------------------------------------------------------------------
  9.  
  10.  
  11. #ifndef __GAMEUTILS__
  12. #include <GameUtils.h>
  13. #endif
  14.  
  15. #ifndef __DEBUGUTILS__
  16. #include <DebugUtils.h>
  17. #endif
  18.  
  19. #ifndef __SPRITEWORLDUTILS__
  20. #include <SpriteWorldUtils.h>
  21. #endif
  22.  
  23. #ifndef __BLITPIXIE__
  24. #include <BlitPixie.h>
  25. #endif
  26.  
  27. #ifndef __SPACEGAME__
  28. #include "SpaceGame.h"
  29. #endif
  30.  
  31. #ifndef __SHIPSPRITE__
  32. #include "ShipSprite.h"
  33. #endif
  34.  
  35.  
  36. OSErr EnterSpaceGame(void)
  37. {
  38.     OSErr err = noErr;
  39.  
  40.         // initialize the random number seed
  41.     GetDateTime((unsigned long *)&qd.randSeed);
  42.  
  43.         // initialize SpriteWorld
  44.     err = SWEnterSpriteWorld();
  45.  
  46.     return err;
  47. }
  48.  
  49.  
  50. void ExitSpaceGame(void)
  51. {
  52.         // shut down SpriteWorld
  53.     SWExitSpriteWorld();
  54. }
  55.  
  56.  
  57. OSErr CreateSpaceGame(
  58.     SpaceGamePtr *spaceGameP)
  59. {
  60.     OSErr err = noErr;
  61.     Rect backFrameRect;
  62.     SpaceGamePtr tempSpaceGameP;
  63.  
  64.     *spaceGameP = NULL;
  65.  
  66.     tempSpaceGameP = (SpaceGamePtr)NewPtrClear((Size)sizeof(SpaceGameRec));
  67.  
  68.     if (tempSpaceGameP == NULL)
  69.     {
  70.         err = MemError();
  71.     }
  72.  
  73.     if (err == noErr)
  74.     {
  75.         err = CreateGameWindow(tempSpaceGameP);
  76.     }
  77.  
  78.     if (err == noErr)
  79.     {
  80.         err = CreateGameSpriteWorld(tempSpaceGameP);
  81.     }
  82.  
  83.     if (err == noErr)
  84.     {
  85.         err = CreateGameLayers(tempSpaceGameP);
  86.     }
  87.  
  88.     if (err == noErr)
  89.     {
  90.         err = CreateSplashScreen(tempSpaceGameP);
  91.     }
  92.  
  93.     if (err == noErr)
  94.     {
  95.         err = CreateGameSprites(tempSpaceGameP);
  96.     }
  97.  
  98.     if (err == noErr)
  99.     {
  100.         *spaceGameP = tempSpaceGameP;
  101.     }
  102.  
  103.     if (err != noErr)
  104.     {
  105.         if (tempSpaceGameP != NULL)
  106.         {
  107.             DisposeSpaceGame(tempSpaceGameP);
  108.         }
  109.     }
  110.  
  111.     return err;
  112. }
  113.  
  114.  
  115. OSErr CreateGameWindow(
  116.     SpaceGamePtr spaceGameP)
  117. {
  118.     OSErr err = noErr;
  119.     WindowPtr gameWindP;
  120.  
  121.     gameWindP = SWHasColorQuickDraw() ?
  122.             GetNewCWindow(1000, NULL, (WindowPtr)-1L) :
  123.             GetNewWindow(1000, NULL, (WindowPtr)-1L);
  124.  
  125.     if (gameWindP == NULL)
  126.     {
  127.         err = ResError();
  128.         
  129.         if (err == noErr)
  130.         {
  131.             err = resNotFound;
  132.         }
  133.     }
  134.  
  135.     if (err == noErr)
  136.     {
  137.         SetPort((GrafPtr)gameWindP);
  138.         TextFont(geneva);
  139.         TextSize(9);
  140.         TextFace(normal);
  141.  
  142.         SizeWindow((WindowPtr)gameWindP,
  143.                         qd.screenBits.bounds.right - qd.screenBits.bounds.left,
  144.                         qd.screenBits.bounds.bottom - qd.screenBits.bounds.top, false);
  145.         MoveWindow((WindowPtr)gameWindP, 0, 0, false);
  146.  
  147.         ShowWindow((WindowPtr)gameWindP);
  148.         FillRect(&gameWindP->portRect, qd.black);
  149.  
  150.         spaceGameP->gameWindP = gameWindP;
  151.     }
  152.  
  153.     return err;
  154. }
  155.  
  156.  
  157. OSErr CreateSplashScreen(
  158.     SpaceGamePtr spaceGameP)
  159. {
  160.     OSErr err = noErr;
  161.     WindowPtr gameWindP = spaceGameP->gameWindP;
  162.     Rect windowRect = gameWindP->portRect;
  163.     Rect titleRect;
  164.     short titleBottom;
  165.  
  166.     if (err == noErr)
  167.     {
  168.         err = SWCreateSpriteFromPictResource(&spaceGameP->titleSpriteP, NULL,
  169.                                                         kSplashPictID, 129, 1, kRegionMask);
  170.     }
  171.  
  172.     if (err == noErr)
  173.     {
  174.         SWAddSprite(spaceGameP->introSpriteLayerP, spaceGameP->titleSpriteP);
  175.         SWAddSpriteLayer(spaceGameP->gameSpriteWorldP, spaceGameP->introSpriteLayerP);
  176.  
  177.         SWLockSpriteWorld(spaceGameP->gameSpriteWorldP);
  178.  
  179.         titleRect = spaceGameP->titleSpriteP->curFrameP->frameRect;
  180.         CenterRect(&gameWindP->portRect, &titleRect);
  181.         titleBottom = titleRect.bottom;
  182.         SWMoveSprite(spaceGameP->titleSpriteP, titleRect.left, titleRect.top);
  183.         SWSetSpriteMoveTime(spaceGameP->titleSpriteP, -1);
  184.  
  185.         SWSetPortToBackGround(spaceGameP->gameSpriteWorldP);
  186.         FillRect(&windowRect, qd.black);
  187.  
  188.         SWUpdateSpriteWorld(spaceGameP->gameSpriteWorldP);
  189.  
  190.         TextFont(systemFont);
  191.         TextSize(12);
  192.         ForeColor(yellowColor);
  193.         titleRect.top = 0;
  194.         titleRect.bottom = 30;
  195.         titleRect.left = 0;
  196.         titleRect.right = StringWidth("\pLoading…");
  197.         CenterRect(&windowRect, &titleRect);
  198.         MoveTo(titleRect.left, titleBottom + ((windowRect.bottom - titleBottom) / 2));
  199.         DrawString("\pLoading…");
  200.         ForeColor(blackColor);
  201.  
  202.         SWUnlockSpriteWorld(spaceGameP->gameSpriteWorldP);
  203.     }
  204.  
  205.     return err;
  206. }
  207.  
  208.  
  209. OSErr CreateGameSpriteWorld(
  210.     SpaceGamePtr spaceGameP)
  211. {
  212.     OSErr err;
  213.  
  214.     err = SWCreateSpriteWorldFromWindow(&spaceGameP->gameSpriteWorldP,
  215.             (CWindowPtr)spaceGameP->gameWindP, NULL);
  216.  
  217.     if (err == noErr)
  218.     {
  219.         SWSetPortToBackGround(spaceGameP->gameSpriteWorldP);
  220.         
  221.         FillRect(&spaceGameP->gameWindP->portRect, qd.black);
  222.  
  223.         SWSetPortToWindow(spaceGameP->gameSpriteWorldP);
  224.     }
  225.  
  226.     return err;
  227. }
  228.  
  229.  
  230. OSErr CreateGameLayers(
  231.     SpaceGamePtr spaceGameP)
  232. {
  233.     OSErr err;
  234.  
  235.     err = SWCreateSpriteLayer(&spaceGameP->introSpriteLayerP);
  236.  
  237.     if (err == noErr)
  238.     {
  239.         err = SWCreateSpriteLayer(&spaceGameP->shipSpriteLayerP);
  240.     }
  241.  
  242.     if (err == noErr)
  243.     {
  244.         err = SWCreateSpriteLayer(&spaceGameP->shotSpriteLayerP);
  245.     }
  246.  
  247.     if (err == noErr)
  248.     {
  249.         err = SWCreateSpriteLayer(&spaceGameP->rockSpriteLayerP);
  250.     }
  251.  
  252.     return err;
  253. }
  254.  
  255.  
  256. OSErr CreateGameSprites(
  257.     SpaceGamePtr spaceGameP)
  258. {
  259.     OSErr err = noErr;
  260.  
  261.     err = CreateShipSprite(&spaceGameP->shipSpriteP);
  262.  
  263.     if (err == noErr)
  264.     {
  265.         InitShipSprite(spaceGameP->shipSpriteP,
  266.                             spaceGameP->gameSpriteWorldP,
  267.                             spaceGameP->shipSpriteLayerP,
  268.                             spaceGameP->shotSpriteLayerP);
  269.     }
  270.  
  271.     if (err == noErr)
  272.     {
  273.         err = CreateShotSpriteArray(spaceGameP->shipSpriteP);
  274.     }
  275.  
  276.     if (err == noErr)
  277.     {
  278.         err = CreateRockSpriteInfo(&spaceGameP->rockSpriteInfoP,
  279.                                             spaceGameP->gameSpriteWorldP,
  280.                                             spaceGameP->rockSpriteLayerP);
  281.     }
  282.  
  283.     return err;
  284. }
  285.  
  286.  
  287. void DisposeSpaceGame(
  288.     SpaceGamePtr spaceGameP)
  289. {
  290.     if (spaceGameP->shipSpriteP != NULL)
  291.     {
  292.         DisposeShipSprite(spaceGameP->shipSpriteP);
  293.     }
  294.  
  295.     if (spaceGameP->rockSpriteInfoP != NULL)
  296.     {
  297.         DisposeRockSpriteInfo(spaceGameP->rockSpriteInfoP);
  298.     }
  299.  
  300.     if (spaceGameP->introSpriteLayerP != NULL)
  301.     {
  302.         SWDisposeSpriteLayer(spaceGameP->introSpriteLayerP);
  303.     }
  304.  
  305.     if (spaceGameP->shipSpriteLayerP != NULL)
  306.     {
  307.         SWDisposeSpriteLayer(spaceGameP->shipSpriteLayerP);
  308.     }
  309.  
  310.     if (spaceGameP->shotSpriteLayerP != NULL)
  311.     {
  312.         SWDisposeSpriteLayer(spaceGameP->shotSpriteLayerP);
  313.     }
  314.  
  315.     if (spaceGameP->rockSpriteLayerP != NULL)
  316.     {
  317.         SWDisposeSpriteLayer(spaceGameP->rockSpriteLayerP);
  318.     }
  319.  
  320.     if (spaceGameP->titleSpriteP != NULL)
  321.     {
  322.         SWDisposeSprite(spaceGameP->titleSpriteP, true);
  323.     }
  324.  
  325.     if (spaceGameP->gameSpriteWorldP != NULL)
  326.     {
  327.         SWDisposeSpriteWorld(spaceGameP->gameSpriteWorldP);
  328.     }
  329.  
  330.     if (spaceGameP->gameWindP != NULL)
  331.     {
  332.         DisposeWindow((WindowPtr)spaceGameP->gameWindP);
  333.     }
  334.  
  335.     DisposePtr((Ptr)spaceGameP);
  336. }
  337.  
  338.  
  339. void IdleSpaceGame(
  340.     SpaceGamePtr spaceGameP)
  341. {
  342.     SWLockSpriteWorld(spaceGameP->gameSpriteWorldP);
  343.  
  344.     SWProcessSpriteWorld(spaceGameP->gameSpriteWorldP);
  345.  
  346.     SWAnimateSpriteWorld(spaceGameP->gameSpriteWorldP);
  347.  
  348.     SWUnlockSpriteWorld(spaceGameP->gameSpriteWorldP);
  349. }
  350.  
  351.  
  352. void StartSpaceGame(
  353.     SpaceGamePtr spaceGameP)
  354. {
  355.     SpriteWorldPtr spriteWorldP = spaceGameP->gameSpriteWorldP;
  356.  
  357.     HideCursor();
  358.  
  359.     HideMenuBar(spaceGameP->gameWindP);
  360.  
  361.     spaceGameP->level = 0;
  362.     spaceGameP->score = 0;
  363.     spaceGameP->lives = 4;
  364.  
  365.     SWAddSpriteLayer(spriteWorldP, spaceGameP->shotSpriteLayerP);
  366.     SWAddSpriteLayer(spriteWorldP, spaceGameP->shipSpriteLayerP);
  367.     SWAddSpriteLayer(spriteWorldP, spaceGameP->rockSpriteLayerP);
  368.  
  369.     SetupShipSprite(spaceGameP->shipSpriteP);
  370.     SetupRockSpriteInfo(spaceGameP->rockSpriteInfoP);
  371.  
  372.     SWLockSpriteWorld(spriteWorldP);
  373.     SWUpdateSpriteWorld(spriteWorldP);
  374.  
  375.     SWSetSpriteWorldEraseProc(spriteWorldP, BlitPixieEraseProc);
  376.     SWSetSpriteWorldDrawProc(spriteWorldP, BlitPixieDrawProc);
  377.  
  378.     PlaySpaceGame(spaceGameP);
  379.  
  380.     SWSetSpriteWorldEraseProc(spriteWorldP, SWStdDrawProc);
  381.     SWSetSpriteWorldDrawProc(spriteWorldP, SWStdMaskDrawProc);
  382.  
  383.     SWRemoveSpriteLayer(spriteWorldP, spaceGameP->shotSpriteLayerP);
  384.     SWRemoveSpriteLayer(spriteWorldP, spaceGameP->shipSpriteLayerP);
  385.     SWRemoveSpriteLayer(spriteWorldP, spaceGameP->rockSpriteLayerP);
  386.     SWUpdateSpriteWorld(spriteWorldP);
  387.  
  388.     ShowMenuBar(spaceGameP->gameWindP);
  389.  
  390.     ShowCursor();
  391.     FlushEvents(everyEvent, 0);
  392. }
  393.  
  394.  
  395. void PlaySpaceGame(
  396.     SpaceGamePtr spaceGameP)
  397. {
  398.     Boolean abortGame = false, fireKeyHasLetUp = true;
  399.     long ticks;
  400.     unsigned long frames = 0;
  401.  
  402.     ticks = TickCount();
  403.  
  404.     while ((spaceGameP->lives > 0) && (!abortGame))
  405.     {
  406.         NextLevel(spaceGameP);
  407.  
  408.         while ((spaceGameP->lives > 0) && (!abortGame))
  409.         {
  410.             if (!spaceGameP->shipSpriteP->isAlive)
  411.             {
  412.                 NextShip(spaceGameP);
  413.             }
  414.  
  415.             for (frames = 0; (spaceGameP->shipSpriteP->isAlive) && (!abortGame); frames++)
  416.             {
  417.                     // fire a shot
  418.                 if (KeyIsDown(kUpArrowKey))
  419.                 {
  420.                     if (fireKeyHasLetUp)
  421.                     {
  422.                         FireAShot(spaceGameP->shipSpriteP);
  423.  
  424.                         fireKeyHasLetUp = false;
  425.                     }
  426.                 }
  427.                 else
  428.                 {
  429.                     fireKeyHasLetUp = true;
  430.                 }
  431.  
  432.                 SWProcessSpriteWorld(spaceGameP->gameSpriteWorldP);
  433.  
  434.                 SWCollideSpriteLayer(spaceGameP->rockSpriteLayerP, spaceGameP->shotSpriteLayerP);
  435.                 SWCollideSpriteLayer(spaceGameP->shipSpriteLayerP, spaceGameP->rockSpriteLayerP);
  436.  
  437.                 SWAnimateSpriteWorld(spaceGameP->gameSpriteWorldP);
  438.  
  439.                 SystemTask();
  440.  
  441.                 abortGame = KeyIsDown(kEscapeKey);
  442.             }
  443.         }
  444.     }
  445.  
  446.     if (KeyIsDown(kOptionKey))
  447.         DebugStrNum("\pFrames Per Second", frames / ((TickCount() - ticks) / 60));
  448. }
  449.  
  450.  
  451. void NextLevel(
  452.     SpaceGamePtr spaceGameP)
  453. {
  454.     short rockNum, numberOfRocks;
  455.     register SpritePtr rockSpriteP;
  456.  
  457.     for (rockSpriteP = NULL; rockSpriteP != NULL;
  458.         rockSpriteP = SWGetNextSprite(spaceGameP->rockSpriteLayerP, rockSpriteP))
  459.     {
  460.         SWRemoveSprite(spaceGameP->rockSpriteLayerP, rockSpriteP);
  461.     }
  462.  
  463.     numberOfRocks = kNumberOfLargeRockSprites / 2;
  464.  
  465.     for (rockNum = 0; rockNum < numberOfRocks; rockNum++)
  466.     {
  467.         rockSpriteP = spaceGameP->rockSpriteInfoP->largeRockSpriteArray[rockNum];
  468.  
  469.         SWAddSprite(spaceGameP->rockSpriteLayerP, rockSpriteP);
  470.     }
  471. }
  472.  
  473.  
  474. void NextShip(
  475.     SpaceGamePtr spaceGameP)
  476. {
  477.     long ticks;
  478.  
  479.     spaceGameP->lives--;
  480.  
  481.     if (spaceGameP->lives > 0)
  482.     {
  483.         ticks = TickCount() + (2 * 60);
  484.  
  485.         while (TickCount() < ticks)
  486.         {
  487.             SWProcessSpriteWorld(spaceGameP->gameSpriteWorldP);
  488.  
  489.             SWAnimateSpriteWorld(spaceGameP->gameSpriteWorldP);
  490.         }
  491.  
  492.         SWSetSpriteVisible((SpritePtr)spaceGameP->shipSpriteP, true);
  493.         SWSetSpriteMoveTime((SpritePtr)spaceGameP->shipSpriteP, kShipMoveTime);
  494.         spaceGameP->shipSpriteP->isAlive = true;
  495.     }
  496. }
  497.  
  498.  
  499. void CenterRect(
  500.     Rect* srcRect,
  501.     Rect* dstRect)
  502. {
  503.     short width = (dstRect->right - dstRect->left);
  504.     short height = (dstRect->bottom - dstRect->top);
  505.  
  506.     dstRect->left = srcRect->left + (((srcRect->right - srcRect->left) / 2) - (width / 2));
  507.     dstRect->top = srcRect->top + (((srcRect->bottom - srcRect->top) / 2) - (height / 2));
  508.     dstRect->right = dstRect->left + width;
  509.     dstRect->bottom = dstRect->top + height;
  510. }
  511.  
  512.  
  513. void GenerateStarField(
  514.     GWorldPtr starGWorldP)
  515. {
  516.     CGrafPtr saveCPort;
  517.     GDHandle saveGDevice;
  518.     PixMapHandle pixMapH;
  519.     unsigned long numberOfStars, numberOfPixels;
  520.     short fieldWidth, fieldHeight;
  521.     short h, v;
  522.     short colorIndex;
  523.     RGBColor foreColor;
  524.     RGBColor saveColor;
  525.     RGBColor starColorArray[21] =
  526.     {
  527.         {
  528.             26214, 26214, 26214
  529.         },
  530.         {
  531.             26214, 26214, 26214
  532.         },
  533.         {
  534.             17476, 17476, 17476
  535.         },
  536.         {
  537.             17476, 17476, 17476
  538.         },
  539.         {
  540.             17476, 17476, 17476
  541.         },
  542.         {
  543.             17476, 17476, 17476
  544.         },
  545.         {
  546.             13107, 13107, 13107
  547.         },
  548.         {
  549.             13107, 13107, 13107
  550.         },
  551.         {
  552.             13107, 13107, 13107
  553.         },
  554.         {
  555.             8738, 8738, 8738
  556.         },
  557.         {
  558.             8738, 8738, 8738
  559.         },
  560.         {
  561.             8738, 8738, 8738
  562.         },
  563.         {
  564.             0, 0, 4369
  565.         },
  566.         {
  567.             0, 0, 4369
  568.         },
  569.         {
  570.             0, 0, 4369
  571.         },
  572.         {
  573.             0, 4369, 0
  574.         },
  575.         {
  576.             0, 4369, 0
  577.         },
  578.         {
  579.             0, 4369, 0
  580.         },
  581.         {
  582.             4369, 0, 0
  583.         },
  584.         {
  585.             4369, 0, 0
  586.         },
  587.         {
  588.             4369, 0, 0
  589.         }
  590.     };
  591.  
  592.     GetGWorld(&saveCPort, &saveGDevice);
  593.     SetGWorld(starGWorldP, NULL);
  594.     pixMapH = GetGWorldPixMap(starGWorldP);
  595.  
  596.     (void)LockPixels(pixMapH);
  597.  
  598.     GetForeColor(&saveColor);
  599.     SetRGBColor(&foreColor, 0, 0, 0);
  600.     RGBForeColor(&foreColor);
  601.     FillRect(&starGWorldP->portRect, qd.black);
  602.  
  603.     fieldWidth = starGWorldP->portRect.right - starGWorldP->portRect.left;
  604.     fieldHeight = starGWorldP->portRect.bottom - starGWorldP->portRect.top;
  605.  
  606.     numberOfPixels = (unsigned long)fieldHeight * (unsigned long)fieldWidth;
  607.     numberOfStars = numberOfPixels / 80U;
  608.  
  609.     while (numberOfStars--)
  610.     {
  611.         colorIndex = GetRandom(0, 20);
  612.  
  613.         RGBForeColor(starColorArray + colorIndex);
  614.  
  615.         MoveTo(GetRandom(0, fieldWidth), GetRandom(0, fieldHeight));
  616.         Line(0, 0);
  617.     }
  618.  
  619.     numberOfStars = GetRandom(1, 6);
  620.  
  621.     while (numberOfStars--)
  622.     {
  623.         h = GetRandom(0, fieldWidth);
  624.         v = GetRandom(0, fieldHeight);
  625.  
  626.             // across
  627.         RGBForeColor(starColorArray + 6);
  628.         MoveTo(h - 1, v + 1);
  629.         Line(2, 0);
  630.  
  631.             // down
  632.         RGBForeColor(starColorArray + 2);
  633.         MoveTo(h, v);
  634.         Line(0, 1);
  635.  
  636.         SetRGBColor(&foreColor, 36128, 36128, 36128);
  637.         RGBForeColor(&foreColor);
  638.         Line(0, 1);
  639.  
  640.         RGBForeColor(starColorArray + 2);
  641.         Line(0, 1);
  642.  
  643.         RGBForeColor(starColorArray + 6);
  644.         Line(0, 0);
  645.     }
  646.  
  647.     if (GetRandom(0, 1))
  648.     {
  649.         CIconHandle cIconH;
  650.         Rect iconRect;
  651.  
  652.         cIconH = GetCIcon(kSuperNovaID);
  653.  
  654.         if (cIconH != NULL)
  655.         {
  656.             iconRect = (**cIconH).iconPMap.bounds;
  657.  
  658.             OffsetRect(&iconRect, GetRandom(20, fieldWidth - 20), GetRandom(20, fieldHeight - 20));
  659.  
  660.             PlotCIcon(&iconRect, cIconH);
  661.             DisposeCIcon(cIconH);
  662.         }
  663.     }
  664.  
  665.     UnlockPixels(pixMapH);
  666.     RGBForeColor(&saveColor);
  667.     SetGWorld(saveCPort, saveGDevice);
  668. }
  669.  
  670.  
  671. void SetRGBColor(
  672.     RGBColor *color,
  673.     short red,
  674.     short green,
  675.     short blue)
  676. {
  677.     color->red = red;
  678.     color->green = green;
  679.     color->blue = blue;
  680. }
  681.